"""
AI报告生成策略模块

实现不同类型报告的生成策略，每种策略负责特定类型报告的数据处理和生成逻辑。
遵循策略模式，确保代码的可扩展性和可维护性。
"""

from typing import Dict, Any, Optional
import pandas as pd
import logging
from datetime import datetime

from ..core.report_generator import BaseReportGenerator, RawData, ProcessedData, ReportResult
from ..service.report_service import AIService, FileService
from ..config.report_config import get_report_config

from dao.es_dao.card_dao import find_imei, get_card_list
from dao.es_dao.i_iot_run_dao import get_iot_run_data, get_equipment_list
from service.battery import get_valid_work_time_detail_group

logger = logging.getLogger(__name__)


class WorkerReportStrategy(BaseReportGenerator):
    """
    工人报告生成策略
    
    负责生成工人工作分析报告，包括出勤率、工作时间、达标情况等分析。
    """
    
    def __init__(self, config: Dict[str, Any] = None):
        super().__init__(config or {})
        self.report_config = get_report_config()
        self.ai_service = AIService(self.report_config)
        self.file_service = FileService(self.report_config)
    
    async def extract_data(self, request_data: Dict[str, Any]) -> RawData:
        """
        提取工人报告所需的数据
        
        Args:
            request_data: 请求数据
            
        Returns:
            RawData: 提取的原始数据
        """
        self.logger.info("开始提取工人报告数据")
        
        # 获取工人IMEI列表
        worker_imei_list = request_data.get('imei_list')
        if worker_imei_list is None:
            worker_imei_list = await find_imei(request_data)
        
        # 获取时间范围
        start_time, end_time, total_days = self.get_time_range(request_data)
        
        # 获取有效工作时间详情
        work_time_data = await get_valid_work_time_detail_group(
            worker_imei_list, start_time, end_time
        )
        
        # 获取卡片列表（基础信息）
        base_info_data = await get_card_list(request_data['projectId'])
        
        # 转换为DataFrame
        df_base = pd.DataFrame(base_info_data)
        df_work = pd.DataFrame(work_time_data)
        
        # 格式化IMEI
        if not df_base.empty:
            df_base = self.format_imei(df_base)
        if not df_work.empty:
            df_work = self.format_imei(df_work)
        
        # 获取部门和成员信息
        metadata = {
            'total_days': total_days,
            'start_time': start_time,
            'end_time': end_time,
            'project_id': request_data['projectId']
        }
        
        if base_info_data:
            metadata.update({
                'depart_name': base_info_data[0].get('departName', ''),
                'member_name': base_info_data[0].get('member', '')
            })
        
        self.logger.info(f"提取数据完成: 基础信息{len(df_base)}条，工作数据{len(df_work)}条")
        
        return RawData(
            base_data=df_base,
            work_data=df_work,
            metadata=metadata
        )
    
    async def transform_data(self, raw_data: RawData, request_data: Dict[str, Any]) -> ProcessedData:
        """
        转换工人报告数据
        
        Args:
            raw_data: 原始数据
            request_data: 请求数据
            
        Returns:
            ProcessedData: 处理后的数据
        """
        self.logger.info("开始转换工人报告数据")
        
        df_base = raw_data.base_data
        df_work = raw_data.work_data
        total_days = raw_data.metadata['total_days']
        
        # 合并数据
        df_all = pd.merge(df_base, df_work, on="imei", how="left")
        
        # 找出无工作记录的员工
        df_null = df_all.loc[df_all['total_steps'].isna(), :]
        no_work_df = df_null[['jobPost', 'nickName', 'jobDutyName']]
        
        # 计算出勤率
        df_clock_in = await self._calculate_attendance_rate(df_base, df_work, total_days)
        
        # 准备CSV格式的数据字符串
        base_csv_str = self.df_to_csv_string(df_base)
        work_csv_str = self.df_to_csv_string(df_work)
        no_work_csv_str = self.df_to_csv_string(no_work_df)
        clock_in_csv_str = self.df_to_csv_string(df_clock_in)
        
        # 统计信息
        statistics = {
            'total_workers': len(df_base),
            'working_workers': len(df_work),
            'no_work_workers': len(no_work_df),
            'average_attendance_rate': df_clock_in['出勤率'].mean() if '出勤率' in df_clock_in.columns else 0
        }
        
        self.logger.info(f"数据转换完成: 总员工{statistics['total_workers']}人，有工作记录{statistics['working_workers']}人")
        
        return ProcessedData(
            statistics=statistics,
            dataframes={
                'base': df_base,
                'work': df_work,
                'all': df_all,
                'no_work': no_work_df,
                'clock_in': df_clock_in
            },
            metrics={
                'base_csv': base_csv_str,
                'work_csv': work_csv_str,
                'no_work_csv': no_work_csv_str,
                'clock_in_csv': clock_in_csv_str
            },
            metadata=raw_data.metadata
        )
    
    async def analyze_with_ai(self, processed_data: ProcessedData, request_data: Dict[str, Any]) -> str:
        """
        使用AI分析工人报告数据
        
        Args:
            processed_data: 处理后的数据
            request_data: 请求数据
            
        Returns:
            str: AI分析结果（HTML格式）
        """
        self.logger.info("开始AI分析工人报告")
        
        # 构建AI提示词
        prompt = await self._build_worker_report_prompt(processed_data)
        
        # 调用AI分析
        ai_result = await self.ai_service.analyze_data(prompt)
        
        self.logger.info("AI分析完成")
        return ai_result
    
    async def generate_output(self, ai_content: str, processed_data: ProcessedData, 
                            request_data: Dict[str, Any]) -> ReportResult:
        """
        生成工人报告输出
        
        Args:
            ai_content: AI生成的内容
            processed_data: 处理后的数据
            request_data: 请求数据
            
        Returns:
            ReportResult: 最终的报告结果
        """
        self.logger.info("开始生成工人报告输出")
        
        try:
            # 生成文件名
            file_name = self.file_service.generate_file_name('worker', processed_data.metadata)
            
            # 创建PDF并上传
            upload_url = await self.file_service.create_and_upload_pdf(ai_content, file_name)
            
            if upload_url:
                full_url = f"{self.report_config.get_oss_base_url()}/{upload_url}"
                
                return ReportResult(
                    success=True,
                    url=full_url,
                    metadata={
                        'file_name': file_name,
                        'statistics': processed_data.statistics,
                        'report_type': 'worker'
                    }
                )
            else:
                return ReportResult(
                    success=False,
                    error_message="报告生成失败，文件上传失败"
                )
                
        except Exception as e:
            self.logger.error(f"生成工人报告输出失败: {str(e)}", exc_info=True)
            return ReportResult(
                success=False,
                error_message=f"生成输出失败: {str(e)}"
            )
    
    async def _calculate_attendance_rate(self, df_base: pd.DataFrame, df_work: pd.DataFrame, 
                                       total_days: int) -> pd.DataFrame:
        """
        计算出勤率
        
        Args:
            df_base: 基础数据
            df_work: 工作数据
            total_days: 总天数
            
        Returns:
            pd.DataFrame: 出勤率数据
        """
        # 合并数据
        df_all = pd.merge(df_base, df_work, on="imei", how="left")
        
        # 填充缺失值
        df_all = df_all.fillna({
            "date": pd.NaT,
            "intensity": 0,
            "total_steps": 0,
            "total_time": 0
        })
        
        # 计算出勤率
        df_clock_in = df_all.groupby("imei").agg(
            工作天数=("date", lambda x: x.nunique())
        ).reset_index()
        
        df_clock_in["总天数"] = total_days
        df_clock_in["出勤率"] = df_clock_in.apply(
            lambda row: (row["工作天数"] / row["总天数"] * 100) if row["总天数"] != 0 else 0,
            axis=1
        )
        
        # 计算达标情况
        df_yx = df_all.groupby(['imei', 'date']).agg(
            daily_steps_sum=('total_steps', 'sum'),
            daily_time_sum=('total_time', 'sum')
        ).reset_index()
        
        # 定义达标条件
        df_yx['达标'] = df_yx.apply(
            lambda row: 1 if row['daily_steps_sum'] > 8000 and row['daily_time_sum'] > 300 else 0,
            axis=1
        )
        
        df_statistic = df_yx.groupby("imei").agg(
            达标天数=("达标", lambda x: (x == 1).sum())
        ).reset_index()
        
        # 合并达标情况
        df_clock_in = pd.merge(df_clock_in, df_statistic, on='imei', how='left')
        
        return df_clock_in
    
    async def _build_worker_report_prompt(self, processed_data: ProcessedData) -> str:
        """
        构建工人报告的AI提示词
        
        Args:
            processed_data: 处理后的数据
            
        Returns:
            str: AI提示词
        """
        metadata = processed_data.metadata
        metrics = processed_data.metrics
        
        start_time = metadata['start_time']
        end_time = metadata['end_time']
        total_days = metadata['total_days']
        member_name = metadata.get('member_name', '')
        depart_name = metadata.get('depart_name', '')
        
        prompt = f"""
        这是一些工人的工作数据。请帮我分析一下他们的工作情况。你现在要做的是帮我输出一份用于物业保洁公司的日常工人工作管理整改数据分析报告。
        
        请严格的计算，不要瞎说八道，也不需要思考很长的逻辑链，你最需要做到的是精确计算，并且给出严谨的回答。
        
        这是基础数据表：{metrics['base_csv']}
        这是工作数据表：{metrics['work_csv']}
        这是无工作记录表：{metrics['no_work_csv']}
        这是出勤统计表：{metrics['clock_in_csv']}
        
        两个表通过IMEI进行链接，展示分析完的结果。
        
        标题为《{member_name}_{depart_name} {start_time.strftime('%Y年%m月%d日')} 至 {end_time.strftime('%Y年%m月%d日')} 工人工作分析报告》
        
        展示内容需要进行美化，输出完整的html格式，考虑宽度是A4输出因为我最终要输出到pdf里，表格内容都要居中，表头文字要加粗，整体样式要一致。
        
        分析内容包括：
        1. 整体出勤率分析
        2. 工作时间分析
        3. 达标情况分析
        4. 问题员工识别
        5. 管理建议
        
        总天数为{total_days}天。
        
        结果直接面向客户，不要有任何中间性的文字输出，输出的任何文字都是面向客户的。
        """
        
        return prompt


class EquipmentReportStrategy(BaseReportGenerator):
    """
    设备报告生成策略
    
    负责生成设备工作分析报告，包括设备出勤率、工作时长、区域分析等。
    """
    
    def __init__(self, config: Dict[str, Any] = None):
        super().__init__(config or {})
        self.report_config = get_report_config()
        self.ai_service = AIService(self.report_config)
        self.file_service = FileService(self.report_config)
    
    async def extract_data(self, request_data: Dict[str, Any]) -> RawData:
        """
        提取设备报告所需的数据
        
        Args:
            request_data: 请求数据
            
        Returns:
            RawData: 提取的原始数据
        """
        self.logger.info("开始提取设备报告数据")
        
        # 获取时间范围
        start_time, end_time, total_days = self.get_time_range(request_data)
        
        # 获取设备列表
        equipment_data = await get_equipment_list(request_data.get('memberId'))
        df_equipment = pd.DataFrame(equipment_data)
        
        # 获取设备运行数据
        iot_run_data = await get_iot_run_data(
            request_data.get('memberId'),
            request_data.get('startDate'),
            request_data.get('endDate'),
            imei_list=df_equipment['imei'].tolist() if not df_equipment.empty else []
        )
        df_iot_run = pd.DataFrame(iot_run_data)
        
        # 数据预处理
        if not df_iot_run.empty:
            df_iot_run['date'] = df_iot_run['date'].str.split('T').str[0]
        
        # 获取成员信息
        metadata = {
            'total_days': total_days,
            'start_time': start_time,
            'end_time': end_time,
            'member_id': request_data.get('memberId'),
            'equipment_count': len(df_equipment)
        }
        
        if equipment_data:
            metadata['member_name'] = equipment_data[0].get('member_name', '')
        
        self.logger.info(f"提取数据完成: 设备{len(df_equipment)}台，运行数据{len(df_iot_run)}条")
        
        return RawData(
            base_data=df_equipment,
            work_data=df_iot_run,
            metadata=metadata
        )
    
    async def transform_data(self, raw_data: RawData, request_data: Dict[str, Any]) -> ProcessedData:
        """
        转换设备报告数据
        
        Args:
            raw_data: 原始数据
            request_data: 请求数据
            
        Returns:
            ProcessedData: 处理后的数据
        """
        self.logger.info("开始转换设备报告数据")
        
        df_equipment = raw_data.base_data
        df_iot_run = raw_data.work_data
        total_days = raw_data.metadata['total_days']
        
        # 合并数据
        df_all = pd.merge(df_equipment, df_iot_run, on="imei", how="left")
        df_all = df_all.fillna({
            "date": pd.NaT,
            "runtime_hours": 0
        })
        
        # 按区域分组统计
        df_group_by_region = df_all.groupby("region_name").agg(
            工作天数=("date", "count"),
        ).reset_index()
        
        df_group_by_region_all_day = df_equipment.groupby("region_name").agg(
            所有天数=("imei", "count")
        ).reset_index()
        
        df_group_by_region_all_day['所有天数'] = df_group_by_region_all_day['所有天数'].astype(int) * total_days
        
        df_region_days = pd.merge(df_group_by_region_all_day, df_group_by_region, on="region_name", how="left")
        df_region_days['大区出勤率'] = (df_region_days['工作天数'] / df_region_days['所有天数']).round(2)
        
        # 准备CSV格式的数据字符串
        equipment_csv_str = self.df_to_csv_string(df_equipment)
        iot_run_csv_str = self.df_to_csv_string(df_iot_run)
        
        # 统计信息
        statistics = {
            'total_equipment': len(df_equipment),
            'active_equipment': len(df_iot_run),
            'regions': df_equipment['region_name'].nunique() if not df_equipment.empty else 0,
            'average_region_attendance': df_region_days['大区出勤率'].mean() if not df_region_days.empty else 0
        }
        
        self.logger.info(f"数据转换完成: 设备{statistics['total_equipment']}台，活跃设备{statistics['active_equipment']}台")
        
        return ProcessedData(
            statistics=statistics,
            dataframes={
                'equipment': df_equipment,
                'iot_run': df_iot_run,
                'all': df_all,
                'region_days': df_region_days
            },
            metrics={
                'equipment_csv': equipment_csv_str,
                'iot_run_csv': iot_run_csv_str
            },
            metadata=raw_data.metadata
        )
    
    async def analyze_with_ai(self, processed_data: ProcessedData, request_data: Dict[str, Any]) -> str:
        """
        使用AI分析设备报告数据
        
        Args:
            processed_data: 处理后的数据
            request_data: 请求数据
            
        Returns:
            str: AI分析结果（HTML格式）
        """
        self.logger.info("开始AI分析设备报告")
        
        # 构建AI提示词
        prompt = await self._build_equipment_report_prompt(processed_data)
        
        # 调用AI分析
        ai_result = await self.ai_service.analyze_data(prompt)
        
        self.logger.info("AI分析完成")
        return ai_result
    
    async def generate_output(self, ai_content: str, processed_data: ProcessedData, 
                            request_data: Dict[str, Any]) -> ReportResult:
        """
        生成设备报告输出
        
        Args:
            ai_content: AI生成的内容
            processed_data: 处理后的数据
            request_data: 请求数据
            
        Returns:
            ReportResult: 最终的报告结果
        """
        self.logger.info("开始生成设备报告输出")
        
        try:
            # 生成文件名
            file_name = self.file_service.generate_file_name('equipment', processed_data.metadata)
            
            # 创建PDF并上传
            upload_url = await self.file_service.create_and_upload_pdf(ai_content, file_name)
            
            if upload_url:
                full_url = f"{self.report_config.get_oss_base_url()}/{upload_url}"
                
                return ReportResult(
                    success=True,
                    url=full_url,
                    metadata={
                        'file_name': file_name,
                        'statistics': processed_data.statistics,
                        'report_type': 'equipment'
                    }
                )
            else:
                return ReportResult(
                    success=False,
                    error_message="报告生成失败，文件上传失败"
                )
                
        except Exception as e:
            self.logger.error(f"生成设备报告输出失败: {str(e)}", exc_info=True)
            return ReportResult(
                success=False,
                error_message=f"生成输出失败: {str(e)}"
            )
    
    async def _build_equipment_report_prompt(self, processed_data: ProcessedData) -> str:
        """
        构建设备报告的AI提示词
        
        Args:
            processed_data: 处理后的数据
            
        Returns:
            str: AI提示词
        """
        metadata = processed_data.metadata
        metrics = processed_data.metrics
        
        start_time = metadata['start_time']
        end_time = metadata['end_time']
        total_days = metadata['total_days']
        member_name = metadata.get('member_name', '')
        equipment_count = metadata['equipment_count']
        
        prompt = f"""
        这是一些清洁设备的工作数据。请帮我分析一下他们的工作情况。你现在要做的是帮我输出一份用于物业保洁公司的日常清洁设备管理整改数据分析报告。
        
        请严格的计算，不要瞎说八道，也不需要思考很长的逻辑链，你最需要做到的是精确计算，并且给出严谨的回答。
        
        这是设备基础数据表：{metrics['equipment_csv']}
        这是工作数据表：{metrics['iot_run_csv']}
        
        两个表通过IMEI进行链接，展示分析完的结果。需要展示设备信息的时候用设备名称alias，展示工作时间的同时展示时间乘以work_amount，单位是work_unit。
        
        标题为《{member_name} {start_time.strftime('%Y年%m月%d日')} 至 {end_time.strftime('%Y年%m月%d日')} 清洁设备工作分析报告》
        
        展示内容需要进行美化，输出完整的html格式，考虑宽度是A4输出因为我最终要输出到pdf里，表格内容都要居中，表头文字要加粗，整体样式要一致。
        
        分析内容包括：
        1. 设备整体出勤率分析 - 总设备数{equipment_count}台，应出勤天数为{total_days}天
        2. 各大区设备出勤率分析和排名
        3. 设备工作时间分析
        4. 设备闲置分析
        5. 达标率分析（以2小时为达标标准）
        6. 管理和整改建议
        
        结果直接面向客户，不要有任何中间性的文字输出，输出的任何文字都是面向客户的。
        """
        
        return prompt


class ProjectReportStrategy(BaseReportGenerator):
    """
    项目报告生成策略
    
    负责生成项目设备统计报告，基于项目维度分析设备使用情况。
    """
    
    def __init__(self, config: Dict[str, Any] = None):
        super().__init__(config or {})
        self.report_config = get_report_config()
        self.ai_service = AIService(self.report_config)
        self.file_service = FileService(self.report_config)
    
    async def extract_data(self, request_data: Dict[str, Any]) -> RawData:
        """
        提取项目报告所需的数据
        
        Args:
            request_data: 请求数据
            
        Returns:
            RawData: 提取的原始数据
        """
        self.logger.info("开始提取项目报告数据")
        
        # 获取时间范围
        start_time, end_time, total_days = self.get_time_range(request_data)
        
        # 获取项目设备运行数据
        iot_run_data = await get_iot_run_data(
            {'projectId': request_data['projectId']},
            request_data.get('startDate'),
            request_data.get('endDate')
        )
        df_iot_run = pd.DataFrame(iot_run_data)
        
        # 获取项目设备列表
        equipment_data = await get_equipment_list({
            "project.id": request_data['projectId']
        })
        df_equipment = pd.DataFrame(equipment_data)
        
        # 数据预处理
        if not df_iot_run.empty:
            df_iot_run = self.format_imei(df_iot_run)
            df_iot_run['date'] = df_iot_run['date'].str.split('T').str[0]
        
        if not df_equipment.empty:
            df_equipment = self.format_imei(df_equipment)
        
        # 获取项目信息
        metadata = {
            'total_days': total_days,
            'start_time': start_time,
            'end_time': end_time,
            'project_id': request_data['projectId'],
            'equipment_count': len(df_equipment)
        }
        
        if equipment_data:
            metadata.update({
                'member_name': equipment_data[0].get('member_name', ''),
                'project_name': equipment_data[0].get('project_name', '')
            })
        
        self.logger.info(f"提取数据完成: 项目设备{len(df_equipment)}台，运行数据{len(df_iot_run)}条")
        
        return RawData(
            base_data=df_equipment,
            work_data=df_iot_run,
            metadata=metadata
        )
    
    async def transform_data(self, raw_data: RawData, request_data: Dict[str, Any]) -> ProcessedData:
        """
        转换项目报告数据
        
        Args:
            raw_data: 原始数据
            request_data: 请求数据
            
        Returns:
            ProcessedData: 处理后的数据
        """
        self.logger.info("开始转换项目报告数据")
        
        df_equipment = raw_data.base_data
        df_iot_run = raw_data.work_data
        
        # 准备CSV格式的数据字符串
        equipment_csv_str = self.df_to_csv_string(df_equipment)
        iot_run_csv_str = self.df_to_csv_string(df_iot_run)
        
        # 统计信息
        statistics = {
            'total_equipment': len(df_equipment),
            'active_equipment': len(df_iot_run),
            'project_id': raw_data.metadata['project_id']
        }
        
        self.logger.info(f"数据转换完成: 项目设备{statistics['total_equipment']}台，活跃设备{statistics['active_equipment']}台")
        
        return ProcessedData(
            statistics=statistics,
            dataframes={
                'equipment': df_equipment,
                'iot_run': df_iot_run
            },
            metrics={
                'equipment_csv': equipment_csv_str,
                'iot_run_csv': iot_run_csv_str
            },
            metadata=raw_data.metadata
        )
    
    async def analyze_with_ai(self, processed_data: ProcessedData, request_data: Dict[str, Any]) -> str:
        """
        使用AI分析项目报告数据
        
        Args:
            processed_data: 处理后的数据
            request_data: 请求数据
            
        Returns:
            str: AI分析结果（HTML格式）
        """
        self.logger.info("开始AI分析项目报告")
        
        # 构建AI提示词
        prompt = await self._build_project_report_prompt(processed_data)
        
        # 调用AI分析
        ai_result = await self.ai_service.analyze_data(prompt)
        
        self.logger.info("AI分析完成")
        return ai_result
    
    async def generate_output(self, ai_content: str, processed_data: ProcessedData, 
                            request_data: Dict[str, Any]) -> ReportResult:
        """
        生成项目报告输出
        
        Args:
            ai_content: AI生成的内容
            processed_data: 处理后的数据
            request_data: 请求数据
            
        Returns:
            ReportResult: 最终的报告结果
        """
        self.logger.info("开始生成项目报告输出")
        
        try:
            # 生成文件名
            file_name = self.file_service.generate_file_name('project', processed_data.metadata)
            
            # 创建PDF并上传
            upload_url = await self.file_service.create_and_upload_pdf(ai_content, file_name)
            
            if upload_url:
                full_url = f"{self.report_config.get_oss_base_url()}/{upload_url}"
                
                return ReportResult(
                    success=True,
                    url=full_url,
                    metadata={
                        'file_name': file_name,
                        'statistics': processed_data.statistics,
                        'report_type': 'project'
                    }
                )
            else:
                return ReportResult(
                    success=False,
                    error_message="报告生成失败，文件上传失败"
                )
                
        except Exception as e:
            self.logger.error(f"生成项目报告输出失败: {str(e)}", exc_info=True)
            return ReportResult(
                success=False,
                error_message=f"生成输出失败: {str(e)}"
            )
    
    async def _build_project_report_prompt(self, processed_data: ProcessedData) -> str:
        """
        构建项目报告的AI提示词
        
        Args:
            processed_data: 处理后的数据
            
        Returns:
            str: AI提示词
        """
        metadata = processed_data.metadata
        metrics = processed_data.metrics
        
        start_time = metadata['start_time']
        end_time = metadata['end_time']
        total_days = metadata['total_days']
        member_name = metadata.get('member_name', '')
        project_name = metadata.get('project_name', '')
        equipment_count = metadata['equipment_count']
        
        prompt = f"""
        这是一些清洁设备的工作数据。请帮我分析一下他们的工作情况。你现在要做的是帮我输出一份用于物业保洁公司的日常清洁设备管理整改数据分析报告。
        
        请严格的计算，不要瞎说八道，也不需要思考很长的逻辑链，你最需要做到的是精确计算，并且给出严谨的回答。
        
        这是设备基础数据表：{metrics['equipment_csv']}
        这是工作数据表：{metrics['iot_run_csv']}
        
        两个表通过IMEI进行链接，展示分析完的结果。需要展示设备信息的时候用设备名称alias，展示工作时间的同时展示时间乘以work_amount，单位是work_unit。
        
        标题为《{member_name}-{project_name} {start_time.strftime('%Y年%m月%d日')} 至 {end_time.strftime('%Y年%m月%d日')} 清洁设备工作分析报告》
        
        展示内容需要进行美化，输出完整的html格式，考虑宽度是A4输出因为我最终要输出到pdf里，表格内容都要居中，表头文字要加粗，整体样式要一致。
        
        分析内容包括：
        1. 项目设备出勤率分析 - 总设备数{equipment_count}台，应出勤天数为{total_days}天
        2. 项目平均有效工作时间分析
        3. 项目设备工作时间随时间变化的趋势分析
        4. 设备达标率分析（以2小时为达标标准）
        5. 管理和整改建议
        
        结果直接面向客户，不要有任何中间性的文字输出，输出的任何文字都是面向客户的。
        """
        
        return prompt